package com.ffggffgfv.backend.controller;

import com.ffggffgfv.backend.dto.UserPermissionDTO;
import com.ffggffgfv.backend.dto.UserRoleDTO;
import com.ffggffgfv.backend.entity.Role;
import com.ffggffgfv.backend.entity.User;
import com.ffggffgfv.backend.service.UserRoleService;
import com.ffggffgfv.backend.service.UserService;
import com.ffggffgfv.backend.util.JWTUtil;
import com.ffggffgfv.backend.util.Result;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 用户角色控制器
 */
@RestController
public class UserRoleController {

    @Autowired
    private UserRoleService userRoleService;

    @Autowired
    private UserService userService;

    @Autowired
    private JWTUtil jwtUtil;

    /**
     * 用户角色分配
     *
     * @param userId      用户ID
     * @param userRoleDTO 角色ID列表DTO
     * @param token       JWT令牌
     * @return 分配结果
     */
    @PostMapping("/api/users/{userId}/roles")
    public Result assignRoles(
            @PathVariable Long userId,
            @RequestBody UserRoleDTO userRoleDTO,
            @RequestHeader("Authorization") String token) {

        // 权限验证（仅管理员）
        if (!validateAdminPermission(token)) {
            return Result.forbidden("无权分配用户角色");
        }

        // 查询用户是否存在
        User user = userService.findById(userId);
        if (user == null) {
            return Result.validateFailed("用户不存在");
        }

        // 分配角色
        boolean result = userRoleService.assignRoles(userId, userRoleDTO);
        if (result) {
            Map<String, Object> data = new HashMap<>();
            data.put("userId", userId);
            data.put("roleCount", userRoleDTO.getRoleIds() != null ?
                    userRoleDTO.getRoleIds().size() : 0);
            return Result.success(data, "角色分配成功");
        } else {
            return Result.validateFailed("角色分配失败");
        }
    }

    /**
     * 获取用户角色
     *
     * @param userId 用户ID
     * @param token  JWT令牌
     * @return 用户角色列表
     */
    @GetMapping("/api/users/{userId}/roles")
    public Result getUserRoles(@PathVariable Long userId, @RequestHeader("Authorization") String token) {
        // 权限验证（管理员或用户本人）
        if (!validatePermission(token, userId)) {
            return Result.forbidden("无权查看");
        }

        // 查询用户是否存在
        User user = userService.findById(userId);
        if (user == null) {
            return Result.validateFailed("用户不存在");
        }

        // 获取用户角色
        List<Role> roles = userRoleService.getUserRoles(userId);
        return Result.success(roles, "获取用户角色成功");
    }

    /**
     * 获取当前用户的权限信息
     *
     * @param token JWT令牌
     * @return 权限信息
     */
    @GetMapping("/api/users/current/permissions")
    public Result getCurrentUserPermissions(@RequestHeader("Authorization") String token) {
        // 从令牌中获取用户ID
        if (token != null && token.startsWith("Bearer ")) {
            token = token.substring(7);
            try {
                Long userId = jwtUtil.extractUserId(token);

                // 获取用户权限信息
                UserPermissionDTO userPermissionDTO = userRoleService.getCurrentUserPermissions(userId);
                return Result.success(userPermissionDTO);

            } catch (Exception e) {
                return Result.unauthorized("无效的令牌");
            }
        } else {
            return Result.unauthorized("未提供令牌");
        }
    }

    /**
     * 验证是否有权操作（管理员或用户本人）
     *
     * @param token  JWT令牌
     * @param userId 用户ID
     * @return 是否有权限
     */
    private boolean validatePermission(String token, Long userId) {
        if (token != null && token.startsWith("Bearer ")) {
            token = token.substring(7);
            try {
                // 管理员可以查看所有用户的角色
                if (jwtUtil.hasAdminRole(token)) {
                    return true;
                }

                // 用户只能查看自己的角色
                Long currentUserId = jwtUtil.extractUserId(token);
                return currentUserId.equals(userId);

            } catch (Exception e) {
                return false;
            }
        }
        return false;
    }

    /**
     * 验证是否具有管理员权限
     *
     * @param token JWT令牌
     * @return 是否有管理员权限
     */
    private boolean validateAdminPermission(String token) {
        if (token != null && token.startsWith("Bearer ")) {
            token = token.substring(7);
            try {
                return jwtUtil.hasAdminRole(token);
            } catch (Exception e) {
                return false;
            }
        }
        return false;
    }
}
